/*
 * 原版接口
 */
import * as server_ui from "@minecraft/server-ui";
import * as server from "@minecraft/server";
/*
 * 蛋白石数据
 */
import * as data_format from "../data/format";
import * as data_story from "../data/story";
/*
 * 蛋白石组件
 */
import * as power_property from "../system/power_property";
import * as derived_tools from "../system/derived_tools";
import * as native_tools from "../system/native_tools";
import * as achieve_plan from "../system/achieve_plan";
import * as math_tools from "../system/math_tools";
/**
 * * 获取 伤害提升
 */
function IncreaseDamage(player: server.Player, container: server.Container, single: boolean = true) {
    // 遍历 背包容器
    for (let index = 0; index < container.size; index++) {
        /**
         * * 获取 物品对象
         */
        const item = container.getItem(index);
        // 排除无效的物品对象
        if (!item || !item.hasTag('data_tag:energy_crystal.series')) continue;
        /**
         * * 获取 物品对象标识
         */
        const typeID = item.typeId.split(/:/)[1];
        // 排除 无法进行强化的 魔晶石
        if (typeID == 'eternal_energy') continue;
        if (single) only(item)
        else all(item);
        break;
    };
    function only(item: server.ItemStack) {
        /**
         * * 进行消耗的样本物品
         */
        const sample = new server.ItemStack(item.typeId);
        /**
         * * 获取 玩家属性面板
         */
        const stages = power_property.GetProperty(player);
        /**
         * * 计算 魔晶武器 攻击提升
         */
        const raise_basic_attack = stages.raise_basic_attack + (stages.basic_attack) * 2;
        // 设置 玩家属性面板
        power_property.AlterProperty(player, { raise_basic_attack });
        // 消耗 物品对象
        native_tools.DeleteItemStack(container, sample);
    };
    function all(item: server.ItemStack) {
        /**
         * * 进行消耗的样本物品
         */
        const sample = new server.ItemStack(item.typeId, item.amount);
        /**
         * * 获取 玩家属性面板
         */
        const stages = power_property.GetProperty(player);
        /**
         * * 计算 魔晶武器 攻击提升
         */
        const raise_basic_attack = ((stages.raise_basic_attack + (stages.basic_attack) * 2) * item.amount) + 3;
        // 设置 玩家属性面板
        power_property.AlterProperty(player, { raise_basic_attack });
        // 消耗 物品对象
        native_tools.DeleteItemStack(container, sample);
    }
};
/**
 * * 魔晶扳手
 */
export function MagicCrystalWrenchTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /** 
             * * 定义了 窗口界面 的 标题 
             */
            const title: server.RawMessage = {
                text: "<§9§o§l 魔晶扳手 §r>§2操作界面"
            };
            /** 
             * * 定义了 窗口界面 的 选项
             */
            const option: server.RawMessage[] = [
                { text: '§l<§n§o 元素附魔 §u-§c 赤焰 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§b 海蓝 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§a 森绿 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§d 紫雷 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§p 橙岩 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§i 白星 §5>§r' },
                { text: '§l<§n§o 元素附魔 §u-§j 黑渊 §5>§r' }
            ];
            /** 
             * * 定义了 窗口界面 的 表单对象
             */
            const display = new server_ui.ActionFormData()
                .title(title)
                .button(option[0], "textures/物品贴图/能量水晶/赤焰_魔晶石")
                .button(option[1], "textures/物品贴图/能量水晶/海蓝_魔晶石")
                .button(option[2], "textures/物品贴图/能量水晶/森绿_魔晶石")
                .button(option[3], "textures/物品贴图/能量水晶/紫雷_魔晶石")
                .button(option[4], "textures/物品贴图/能量水晶/橙岩_魔晶石");
            /**
             * * 设置元素附魔
             * 
             * @param nameTag - 名称标签
             * @param selfRune - 自身的附魔类型
             */
            const enchanting = (nameTag: string, selfRune: string) => {
                // 为物品添加动态属性
                item.setDynamicProperty('rune_hurt:self_rune', selfRune);
                // 设置物品名称
                item.nameTag = nameTag;
                // 为物品添加词缀
                item.setLore(['攻击命中后, 将获得' + nameTag]);
                // 设置 物品对象
                container.setItem(player.selectedSlotIndex, item);
                // 播放 音效
                player.playSound('block.enchanting_table.use');
            };
            // 播放 音效
            player.playSound('tile.piston.out');
            // 显示窗口界面
            display.show(player).then(
                option => {
                    if (option.canceled) return;
                    switch (option.selection) {
                        //元素附魔 - 赤焰
                        case 0: enchanting('§l<§n§o 元素附魔 §u-§c 赤焰 §5>§r', data_format.RUNE_ENUM.red); break;
                        //元素附魔 - 海蓝
                        case 1: enchanting('§l<§n§o 元素附魔 §u-§b 海蓝 §5>§r', data_format.RUNE_ENUM.blue); break;
                        //元素附魔 - 森绿
                        case 2: enchanting('§l<§n§o 元素附魔 §u-§a 森绿 §5>§r', data_format.RUNE_ENUM.green); break;
                        //元素附魔 - 紫雷
                        case 3: enchanting('§l<§n§o 元素附魔 §u-§d 紫雷 §5>§r', data_format.RUNE_ENUM.purple); break;
                        //元素附魔 - 橙岩
                        case 4: enchanting('§l<§n§o 元素附魔 §u-§p 橙岩 §5>§r', data_format.RUNE_ENUM.orange); break;
                        //元素附魔 - 白星
                        case 5: enchanting('§l<§n§o 元素附魔 §u-§i 白星 §5>§r', data_format.RUNE_ENUM.white); break;
                        //元素附魔 - 黑渊
                        case 6: enchanting('§l<§n§o 元素附魔 §u-§j 黑渊 §5>§r', data_format.RUNE_ENUM.black); break;
                    }
                }
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
        },
        onHitEntity(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.attackingEntity;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 触发自定义组件的目标实体
             */
            const target = source.hitEntity;
            // 判断条件是否满足
            if (!(player instanceof server.Player) || !item || !target || !container) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 10)) return;
            /**
             * * 获取 玩家属性面板
             */
            const stages = power_property.GetProperty(player);
            /**
             * * 粒子名称
             */
            const particle = stages.self_rune != 'rune_void' ? 'constant:impact_' + stages.self_rune : 'minecraft:sonic_explosion';
            /**
             * * 设置 范围查询 的 过滤条条件
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
                excludeFamilies: ['starry'],
                location: target?.location,
                maxDistance: 4,
                closest: 8
            };
            /**
             * * 获取 目标周围的实体
             */
            const getQueue = player.dimension.getEntities(options).filter(entity => entity.id !== player.id);
            /**
             * * 是否暴击
             */
            const erupt = derived_tools.IsErupt(player);
            /**
             * * 获取 元素附魔类型
             */
            const self_rune = item.getDynamicProperty('rune_hurt:self_rune') as string ?? 'rune_void';
            // 对 玩家属性 进行 修改
            power_property.SetProperty(player, { self_rune: self_rune as data_format.RUNE_TYPE });
            // 获取属性提升值
            IncreaseDamage(player, container);
            // 对选中的实体队列造成伤害
            getQueue.forEach(entity => achieve_plan.RunePowerAttack.BriefCreate(player, entity, erupt));
            // 生成 粒子特效
            native_tools.TrySpawnParticle(player.dimension, "minecraft:huge_explosion_emitter", target?.location ?? player.location);
            native_tools.TrySpawnParticle(player.dimension, particle, target?.location ?? player.location);
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 魔晶弹珠
 */
export function MagicCrystalMarblesTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            // 播放 动画
            player.playAnimation('animation.item.common.resist', { blendOutTime: 0.5 });
            // 播放 音效
            player.playSound('item.trident.riptide_1');
            /**
             * * 获取 玩家指向的实体
             */
            const target = player.getEntitiesFromViewDirection({ maxDistance: 48 })[0]?.entity;
            // 确认 目标实体是否存在
            if (!target || !target.isValid()) return;
            /**
             * * 设置 范围查询 的 过滤条条件
             */
            const options: server.EntityQueryOptions = {
                excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
                excludeFamilies: ['starry'],
                location: target.location,
                maxDistance: 8,
                closest: 8
            };
            /**
             * * 获取 目标周围的实体
             */
            const queue = player.dimension.getEntities(options).filter(entity => entity.id !== player.id);
            // 确认 目标实体是否存在
            if (queue.length == 0 || !target) return;
            // 获取属性提升值
            IncreaseDamage(player, container, false);
            /**
             * * 获取 玩家属性面板
             */
            const data = power_property.GetProperty(player);
            /**
             * * 爆炸效果 粒子名称
             */
            const blastParticle = 'constant:fireworks_fireball_' + data.self_rune;
            /**
             * * 是否暴击
             */
            const erupt = derived_tools.IsErupt(player);
            /**
             * * 定义 粒子参数
             */
            const molang = new server.MolangVariableMap();
            /**
             * * 玩家 与 目标 之间的距离
             */
            const distance = math_tools.Vector.distance(player.location, target.location);
            /**
             * * 进行消耗的样本物品
             */
            const sample = new server.ItemStack(item.typeId);
            // 消耗 物品对象
            native_tools.DeleteItemStack(container, sample);
            // 设置 粒子参数
            molang.setColorRGB('variable.color', data_story.getRuneColor(data.self_rune));
            molang.setVector3('variable.direction', player.getViewDirection());
            molang.setFloat('variable.range', distance);
            molang.setFloat('variable.type', 0);
            // 播放 粒子效果
            player.spawnParticle('scripts:path_spurt', player.getHeadLocation(), molang);
            // 延迟 触发 元素伤害
            server.system.runTimeout(
                () => {
                    if (!target || !target.isValid()) return;
                    // 对选中的实体队列造成伤害
                    queue.forEach(entity => achieve_plan.RunePowerAttack.BriefCreate(player, entity, erupt, data));
                    // 创建 爆炸粒子
                    if (queue.length > 1) native_tools.TrySpawnParticle(player.dimension, blastParticle, target.location);
                },
                distance
            );
        }
    }
};
/**
 * * 魔晶弹弓
 */
export function MagicCrystalBowTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 10)) return;
            // 执行 弹弓照明 机制
            if (player.isSneaking) BowSneaking(player)
            // 如果 玩家 不在潜行模式
            else {
                /**
                 * * 获取 玩家属性面板
                 */
                const data = power_property.GetProperty(player);
                // 对 属性 进行 初始化
                power_property.SetProperty(player, { raise_basic_attack: 0 });
                // 获取属性提升值
                IncreaseDamage(player, container);
                // 生成 粒子特效
                player.spawnParticle('constant:excite_' + data.self_rune, player.getHeadLocation());
            }
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 魔晶弹弓 - 弹道运行
 */
function BowTick(args: data_format.ROUTE_ANNEX_ARGS): boolean {
    /**
     * * 获取 方块对象
     */
    const getBlock = args.dimension.getBlock(args.location);
    if (!getBlock || !getBlock.isValid()) return false;
    if (getBlock && getBlock.isAir) return true;
    return false;
};
/**
 * * 魔晶弹弓 - 弹道终止
 */
function BowStop(args: data_format.ROUTE_ANNEX_ARGS) {
    /**
     * * 获取 方块对象
     */
    const block = args.dimension.getBlock(args.location);
    // 确认 目标方块是否存在
    if (!block || !block.isValid()) return;
    /**
     * * 目标方块周围的方块队列
     */
    const blocks: server.Block[] = [];
    //获取 目标附近 的 全部方块
    for (let axleX = -1; axleX < 2; axleX++) for (let axleY = -1; axleY < 2; axleY++) for (let axleZ = -1; axleZ < 2; axleZ++) {
        /**
         * * 获取 方块对象
         */
        const sample = block.offset({ x: axleX, y: axleY, z: axleZ });
        //写入方块信息
        if (sample) blocks.push(sample);
    };
    //遍历方块队列 并点亮方块
    for (let index = 0; index < blocks.length; index++) {
        if (!blocks[index].isAir || blocks[index].below()?.isAir || blocks[index].below()?.isLiquid) continue;
        blocks[index].setPermutation(server.BlockPermutation.resolve('minecraft:soul_torch'));
        break;
    };
};
/**
 * * 魔晶弹弓 - 潜行时
 */
function BowSneaking(object: server.Player) {
    // 创建 路径包
    achieve_plan.PathExecute.Create('魔晶弹弓-照明射线', 1,
        {
            particles: ['constant:track_color_yellow'],
            dimension: object.dimension,
            location_group: [],
            on_move: BowTick,
            on_done: BowStop,
            cooldown: 1,
            speed: 1,
            shoot: {
                start_place: object.getHeadLocation(),
                toward: object.getViewDirection(),
                max_distance: 128
            }
        }
    )
};
/**
 * * 魔晶弹弓 - 命中后
 */
export function BowHitAfter(object: server.Player, target?: server.Entity) {
    /**
     * * 获取 玩家的 状态属性
     */
    const data = power_property.GetProperty(object);
    /**
     * * 定义 粒子参数
     */
    const molang = new server.MolangVariableMap();
    if (!target) return;
    // 设置 粒子参数
    molang.setColorRGB('variable.color', data_story.getRuneColor(data.self_rune));
    molang.setVector3('variable.direction', math_tools.Vector.CONSTANT_DOWN);
    molang.setFloat('variable.range', 5);
    molang.setFloat('variable.type', 0);
    // 播放 粒子效果
    object.spawnParticle('scripts:path_spurt', math_tools.Vector.add(target.location, { x: 0, y: 5, z: 0 }), molang);
    /**
     * * 是否暴击
     */
    const erupt = derived_tools.IsErupt(object);
    // 触发 魔晶弹弓 追击伤害
    achieve_plan.RunePowerAttack.Create(object.id, 10, { target: target, self: object, erupt });
};
/**
 * * 魔晶起子
 */
export function MagicCrystalScrewdriverTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 20)) return;
            /**
             * * 设置界面标题
             */
            const title: server.RawMessage = {
                text: "<§9§o§l 区块连锁 §r>§2操作界面"
            };
            /**
             * * 设置界面内容
             */
            const label: server.RawMessage = { text: '区块连锁 -> 用法' };
            /**
             * * 设置界面滑动条
             */
            const slider: server.RawMessage[] = [
                { text: '<§9§o§l 区块连锁 §r>极限深度§r' },
                { text: '<§9§o§l 区块连锁 §r>极限高度§r' },
                { text: '<§9§o§l 区块连锁 §r>极限范围§r' }
            ];
            /**
             * * 设置界面下拉框
             */
            const option: server.RawMessage[] = [
                { text: '§l§1[§9 潜行触发 §1]§r' },
                { text: '§l§c[§c 关闭功能 §c]§r' },
                { text: '§l§1[§4 始终触发 §1]§r' }
            ];
            // 设置界面
            new server_ui.ModalFormData()
                .title(title)
                .slider(slider[0], -8, -1, 1, -6)
                .slider(slider[1], 1, 8, 1, 6)
                .slider(slider[2], 4, 8, 1, 6)
                .dropdown(label, option, 1)
                .show(player).then(
                    popup => {
                        if (popup.canceled) return;
                        /**
                         * * 功能类型
                         */
                        const mode = ['潜行', undefined, '始终'];
                        // 获取 窗口值
                        const formValues: number[] = popup.formValues as number[];
                        // 显示 功能类型
                        player.sendMessage(option[formValues[3]]);
                        // 设置 区块连锁 类型
                        player.setDynamicProperty('block_chain:type', mode[formValues[3]]);
                        // 设置 区块连锁 深度
                        player.setDynamicProperty('block_chain:depth', formValues[0]);
                        // 设置 区块连锁 高度
                        player.setDynamicProperty('block_chain:height', formValues[1]);
                        // 设置 区块连锁 范围
                        player.setDynamicProperty('block_chain:range', formValues[2]);
                    }
                );
            //播放音效
            player.playSound("break.amethyst_block");
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};
/**
 * * 魔晶锄头
 */
export function MagicCrystalHoeTrigger(): server.ItemCustomComponent {
    return {
        onUse(source) {
            /**
             * * 触发自定义组件的玩家
             */
            const player = source.source;
            /**
             * * 触发自定义组件的物品
             */
            const item = source.itemStack;
            /**
             * * 玩家背包
             */
            const container = player.getComponent('inventory')?.container;
            // 判断条件是否满足
            if (!container || !player || !item) return;
            // 判断是否冷却完成
            if (!achieve_plan.ControlEventTrigger.EntityToken(item.typeId, player, 60)) return;
            //播放音效
            player.playSound("random.bow");
            /**
             * * 获取 方块
             */
            const getBlock = player.getBlockFromViewDirection({ maxDistance: 128 })?.block;
            // 确认 目标方块是否存在
            if (!getBlock || !getBlock.isValid()) return;
            /**
             * * 目标方块周围的方块队列
             */
            const getGroup: server.Block[] = [];
            //获取 目标附近 的 全部方块
            for (let axleX = -2; axleX < 2; axleX++) for (let axleY = -2; axleY < 2; axleY++) for (let axleZ = -2; axleZ < 2; axleZ++) {
                /**
                 * * 备选 目标点
                 */
                const current = getBlock.offset({ x: axleX, y: axleY, z: axleZ });
                /**
                 * * 获取 目标上方的方块
                 */
                const above = getBlock.offset({ x: axleX, y: axleY + 1, z: axleZ });
                //写入方块信息
                if (current?.isAir && above?.isAir) getGroup.push(current);
            };
            /**
             * * 定义 相机参数
             */
            const camera = player.camera;
            /**
             * * 状态效果 参数
             */
            const options: server.EntityEffectOptions = {
                amplifier: 0,
                showParticles: false
            };
            // 判断 目标方块队列是否为空
            if (getGroup.length < 1) return;
            /**
             * * 获取 目标方块
             */
            const block = getGroup[0];
            // 清除 摄像机动画
            server.system.runTimeout(() => camera.clear(), 40);
            // 设置 摄像机位移
            camera.setCamera('minecraft:free', { location: block, rotation: player.getRotation(), easeOptions: { easeTime: 2 } });
            // 生成 粒子特效
            native_tools.TrySpawnParticle(block.dimension, 'constant:magic_hoe', block.location);
            // 设置 屏幕渐变
            server.system.runTimeout(() => camera.fade({ fadeColor: { red: 0, green: 0, blue: 0 }, fadeTime: { fadeInTime: 0.2, fadeOutTime: 0.3, holdTime: 0.5 } }), 30);
            // 执行传送流程
            server.system.runTimeout(
                () => {
                    player.tryTeleport(block);
                    // 显示 状态效果
                    player.addEffect("slow_falling", 200, options);
                    player.addEffect("levitation", 80, options);
                }, 40
            );
            // 更新 物品冷却
            item.getComponent('minecraft:cooldown')?.startCooldown(player);
            // 更新 物品耐久
            native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
        }
    }
};

/**
 * * 魔晶盾牌
 */
export function MagicCrystalShield(player: server.Player, item: server.ItemStack, slot: server.EquipmentSlot) {
    /**
     * * 装备容器
     */
    const equippable = player.getComponent('minecraft:equippable');
    // 播放 动画
    player.playAnimation('animation.item.shield.resist', { blendOutTime: 0.5 });
    // 播放 声音
    player.playSound('item.shield.block');
    // 修改物品属性
    equippable?.setEquipment(slot, native_tools.AlterDurability(item, 1));
    // 检测 是否完成冷却
    if (!achieve_plan.ControlEventTrigger.EntityToken('魔晶盾牌:伤害反射', player, 60)) return;
    if (!player.isSneaking) return;
    // 更新 物品冷却
    item.getComponent('minecraft:cooldown')?.startCooldown(player);
    // 弹反伤害
    ShieldReflexDamage(player, item);
};
/**
 * * 魔晶盾牌 - 伤害弹反
 */
function ShieldReflexDamage(player: server.Player, item: server.ItemStack) {
    /**
     * * 过滤条条件
     */
    const options: server.EntityQueryOptions = {
        excludeTypes: ["minecraft:item", "minecraft:xp_orb"],
        excludeFamilies: ['starry'],
        location: player.location,
        maxDistance: 4
    };
    /**
     * * 获取 玩家的属性面板
     */
    const getData = power_property.GetProperty(player);
    // 造成 弹反伤害
    player.dimension.getEntities(options).filter(entity => entity.id !== player.id).forEach(entity => achieve_plan.RunePowerAttack.Create('SprayPack', 1, { target: entity, self: player, erupt: true, hurt_data: getData }));
    // 生成 粒子效果
    if (getData.self_rune !== data_format.RUNE_ENUM.void) native_tools.TrySpawnParticle(player.dimension, `constant:impact_${getData.self_rune}`, player.location);
    if (getData.self_rune === data_format.RUNE_ENUM.void) native_tools.TrySpawnParticle(player.dimension, 'minecraft:sonic_explosion', player.location);
    // 更新 物品冷却
    item.getComponent('minecraft:cooldown')?.startCooldown(player);
};
/**
 * * 魔晶锤子
 */
export function MagicCrystalHammer(player: server.Player, item: server.ItemStack, container: server.Container, block?: server.Block) {
    /**
     * * 获取 金属锭 所处的 方块对象
     */
    const pointer = block?.above();
    // 确认 目标方块是否存在
    if (!pointer) return;
    /**
     * * 获取 金属锭 物品对象
     */
    const material = pointer.dimension.getEntitiesAtBlockLocation(pointer.location);
    // 遍历 金属锭 物品对象
    for (let index = 0; index < material.length; index++) {
        /**
         * * 获取 金属锭 物品对象
         */
        const item = material[index].getComponent('item')?.itemStack;
        // 如果物品不存在 或 数量不足
        if (!item || item?.amount < 4) continue;
        /**
         * * 获取 锻压类型 标签
         */
        const tags = item?.getTags().filter(tag => tag.startsWith('data_tag:mineral_resources.make'));
        // 如果 锻压类型 标签不存在
        if (tags.length == 0) continue;
        /**
         * * 获取 锻压类型
         */
        const type = tags[0].split('.')[2];
        /**
         * * 获取 物品锻压阶段
         */
        const stage = item.typeId.split(':')[1].split('.').length;
        /**
         * * 获取 物品名称
         */
        const name = stage == 1 ? item.typeId.split(':')[1] : item.typeId.split(':')[1].split('.')[1];
        // 删除 金属锭 物品对象
        material[index].remove();
        // 消耗 物品数量
        if (item.amount > 4) {
            item.amount -= 4;
            native_tools.TrySpawnItem(pointer.dimension, item, pointer.center());
        };
        // 生成 金属板 物品对象
        native_tools.TrySpawnItem(pointer.dimension, new server.ItemStack('item_mineral:' + type + '.' + name), pointer.center());
        player.playSound('random.anvil_use');
        break;
    };
    // 更新 物品冷却
    item.getComponent('minecraft:cooldown')?.startCooldown(player);
    // 更新 物品耐久
    native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
};
/**
 * * 魔晶钥匙
 */
export function MagicCrystalKey(player: server.Player, item: server.ItemStack, container: server.Container, block?: server.Block) {
    /**
     * * 方块白名单
     */
    const whiteList = new Set<string>(
        [
            'minecraft:trial_spawner',
            'minecraft:mob_spawner',
            'minecraft:vault'
        ]
    );
    /**
     * * 获取 容器对象
     */
    const inventory = block?.getComponent('inventory')?.container;
    // 确认 目标方块是否存在
    if (!block) return;
    // 确认 目标方块是否为容器或白名单
    if (!inventory && !whiteList.has(block?.typeId)) return;
    /**
     * * 获取 容器的物品对象
     */
    const chest = block.getItemStack(1, true);
    // 为 容器的物品对象 附加词缀
    if (chest) chest.setLore(
        [
            `搬运者: ${player.nameTag}`,
            `源坐标: ${math_tools.Vector.toString(block)}`,
            `源维度: ${block.dimension.id}`
        ]
    );
    // 生成 容器的物品对象
    if (chest) native_tools.TrySpawnItem(block.dimension, chest, block.center());
    // 清空容器内容
    if (inventory) for (let index = 0; index < inventory.size; index++) inventory.setItem(index);
    // 移除容器方块
    block.setPermutation(server.BlockPermutation.resolve('minecraft:air'));
    // 播放音效
    player.playSound('block.barrel.open');
    // 更新 物品冷却
    item.getComponent('minecraft:cooldown')?.startCooldown(player);
    // 更新 物品耐久
    native_tools.SetDurability(player, item, container, player.selectedSlotIndex, 1);
};
